#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
GitLab TimescaleDB 包功能测试脚本

测试新创建的 gitlab_timescale 包的各项功能：
1. 包导入测试
2. 配置加载测试
3. 数据库连接测试
4. GitLab连接测试
5. 基本功能验证
"""

import sys
from pathlib import Path

from loguru import logger

# 添加包路径
sys.path.insert(0, str(Path(__file__).parent))


def test_package_imports():
    """测试包导入"""
    logger.info("=== 测试1: 包导入测试 ===")

    try:
        # 测试主要模块导入
        try:
            from gitlab_timescale import (
                get_config,
                setup_logging,
                TimescaleDBManager,
                GitLabTimescaleCollector,
                GitLabTimescaleAnalyzer
            )
            logger.info("✅ 主要模块导入成功")
        except ImportError:
            # 如果包导入失败，尝试直接导入模块
            from gitlab_timescale.config import get_config, setup_logging
            from gitlab_timescale.models import TimescaleDBManager
            from gitlab_timescale.collector import GitLabTimescaleCollector
            from gitlab_timescale.analyzer import GitLabTimescaleAnalyzer
            logger.info("✅ 主要模块直接导入成功")

        # 测试Legacy模块导入
        try:
            from gitlab_timescale import (
                GitLabCommitsAnalyzer,
                GitLabReposFetcher,
                GitLabUsersCollector
            )
            logger.info("✅ Legacy模块导入成功")
        except ImportError:
            from gitlab_timescale.legacy import GitLabCommitsAnalyzer, GitLabReposFetcher, GitLabUsersCollector
            logger.info("✅ Legacy模块直接导入成功")

        # 测试子模块导入
        from gitlab_timescale.config import GitLabConfig, DatabaseConfig
        from gitlab_timescale.collector import SyncConfig
        from gitlab_timescale.analyzer import AnalysisConfig
        logger.info("✅ 子模块导入成功")

        return True

    except ImportError as e:
        logger.error(f"❌ 导入失败: {e}")
        return False
    except Exception as e:
        logger.error(f"❌ 导入异常: {e}")
        return False


def test_config_loading():
    """测试配置加载"""
    logger.info("\n=== 测试2: 配置加载测试 ===")

    try:
        from gitlab_timescale import get_config, setup_logging

        # 测试配置加载
        config = get_config()
        logger.info(f"✅ 配置加载成功")
        logger.info(f"  GitLab URL: {config.gitlab.url}")
        logger.info(f"  数据库主机: {config.database.host}")
        logger.info(f"  数据库名称: {config.database.database}")

        # 测试日志设置
        setup_logging(config.log)
        logger.info("✅ 日志设置成功")

        return True, config

    except Exception as e:
        logger.error(f"❌ 配置加载失败: {e}")
        return False, None


def test_database_connection(config):
    """测试数据库连接"""
    logger.info("\n=== 测试3: 数据库连接测试 ===")

    try:
        from gitlab_timescale import TimescaleDBManager

        # 创建数据库管理器
        db_manager = TimescaleDBManager(
            connection_string=config.database.connection_string,
            min_connections=1,
            max_connections=2
        )
        logger.info("✅ 数据库管理器创建成功")

        # 测试连接
        if db_manager.test_connection():
            logger.info("✅ 数据库连接测试成功")
            return True, db_manager
        else:
            logger.error("❌ 数据库连接测试失败")
            return False, None

    except Exception as e:
        logger.error(f"❌ 数据库连接异常: {e}")
        return False, None


def test_gitlab_connection(config):
    """测试GitLab连接"""
    logger.info("\n=== 测试4: GitLab连接测试 ===")

    try:
        from gitlab_timescale import GitLabTimescaleCollector

        # 创建收集器（不需要数据库管理器来测试连接）
        collector = GitLabTimescaleCollector(
            gitlab_url=config.gitlab.get_default_instance().url,
            access_token=config.gitlab.get_default_instance().access_token,
            db_manager=None  # 仅测试GitLab连接
        )
        logger.info("✅ GitLab收集器创建成功")

        # 测试连接
        if collector.test_connection():
            logger.info("✅ GitLab连接测试成功")
            return True, collector
        else:
            logger.error("❌ GitLab连接测试失败")
            return False, None

    except Exception as e:
        logger.error(f"❌ GitLab连接异常: {e}")
        return False, None


def test_legacy_modules(config):
    """测试Legacy模块"""
    logger.info("\n=== 测试5: Legacy模块测试 ===")

    try:
        from gitlab_timescale import (
            GitLabCommitsAnalyzer,
            GitLabReposFetcher,
            GitLabUsersCollector
        )

        # 测试提交分析器
        commits_analyzer = GitLabCommitsAnalyzer(
            access_token=config.gitlab.get_default_instance().access_token,
            gitlab_url=config.gitlab.get_default_instance().url
        )
        logger.info("✅ GitLab提交分析器创建成功")

        # 测试仓库获取器
        repos_fetcher = GitLabReposFetcher(
            access_token=config.gitlab.get_default_instance().access_token,
            gitlab_url=config.gitlab.get_default_instance().url
        )
        logger.info("✅ GitLab仓库获取器创建成功")

        # 测试用户收集器
        users_collector = GitLabUsersCollector(
            gitlab_url=config.gitlab.get_default_instance().url,
            access_token=config.gitlab.get_default_instance().access_token
        )
        logger.info("✅ GitLab用户收集器创建成功")

        # 测试用户收集器连接
        if users_collector.test_connection():
            logger.info("✅ 用户收集器连接测试成功")
        else:
            logger.warning("⚠️ 用户收集器连接测试失败")

        return True

    except Exception as e:
        logger.error(f"❌ Legacy模块测试异常: {e}")
        return False


def test_basic_functionality(db_manager):
    """测试基本功能"""
    logger.info("\n=== 测试6: 基本功能测试 ===")

    if db_manager is None:
        logger.warning("⚠️ 跳过基本功能测试（数据库连接失败）")
        return False

    try:
        from gitlab_timescale import GitLabTimescaleAnalyzer

        # 创建分析器
        analyzer = GitLabTimescaleAnalyzer(db_manager)
        logger.info("✅ 分析器创建成功")

        # 测试获取统计信息（可能为空，但不应该报错）
        try:
            project_stats = db_manager.get_project_branch_stats()
            logger.info(f"✅ 获取项目统计成功 (共 {len(project_stats)} 条记录)")
        except Exception as e:
            logger.warning(f"⚠️ 获取项目统计失败: {e}")

        try:
            user_stats = db_manager.get_user_contribution_stats()
            logger.info(f"✅ 获取用户统计成功 (共 {len(user_stats)} 条记录)")
        except Exception as e:
            logger.warning(f"⚠️ 获取用户统计失败: {e}")

        return True

    except Exception as e:
        logger.error(f"❌ 基本功能测试异常: {e}")
        return False


def test_schema_file_exists():
    """测试数据库架构文件是否存在"""
    logger.info("\n=== 测试7: 数据库架构文件检查 ===")

    schema_file = Path(__file__).parent / "gitlab_timescale_schema.sql"

    if schema_file.exists():
        logger.info(f"✅ 数据库架构文件存在: {schema_file}")

        # 检查文件内容
        try:
            with open(schema_file, 'r', encoding='utf-8') as f:
                content = f.read()
                if 'CREATE TABLE' in content and 'gitlab_commits' in content:
                    logger.info("✅ 架构文件内容检查通过")
                    return True
                else:
                    logger.warning("⚠️ 架构文件内容可能不完整")
                    return False
        except Exception as e:
            logger.error(f"❌ 读取架构文件失败: {e}")
            return False
    else:
        logger.error(f"❌ 数据库架构文件不存在: {schema_file}")
        return False


def main():
    """主测试函数"""
    logger.info("🧪 GitLab TimescaleDB 包功能测试")
    logger.info("=" * 50)

    test_results = []

    # 测试1: 包导入
    result1 = test_package_imports()
    test_results.append(("包导入测试", result1))

    if not result1:
        logger.error("\n❌ 包导入失败，无法继续后续测试")
        return

    # 测试2: 配置加载
    result2, config = test_config_loading()
    test_results.append(("配置加载测试", result2))

    if not result2:
        logger.error("\n❌ 配置加载失败，无法继续后续测试")
        return

    # 测试3: 数据库连接
    result3, db_manager = test_database_connection(config)
    test_results.append(("数据库连接测试", result3))

    # 测试4: GitLab连接
    result4, collector = test_gitlab_connection(config)
    test_results.append(("GitLab连接测试", result4))

    # 测试5: Legacy模块
    result5 = test_legacy_modules(config)
    test_results.append(("Legacy模块测试", result5))

    # 测试6: 基本功能
    result6 = test_basic_functionality(db_manager)
    test_results.append(("基本功能测试", result6))

    # 测试7: 架构文件
    result7 = test_schema_file_exists()
    test_results.append(("架构文件检查", result7))

    # 汇总结果
    logger.info("\n" + "=" * 50)
    logger.info("📊 测试结果汇总:")
    logger.info("=" * 50)

    passed = 0
    total = len(test_results)

    for test_name, result in test_results:
        status = "✅ 通过" if result else "❌ 失败"
        logger.info(f"  {test_name}: {status}")
        if result:
            passed += 1

    logger.info(f"\n总计: {passed}/{total} 个测试通过")

    if passed == total:
        logger.info("\n🎉 所有测试通过！包功能正常")
        logger.info("\n💡 下一步操作建议:")
        logger.info("  1. 运行 'python gitlab_timescale/sync_script.py --init-db' 初始化数据库")
        logger.info("  2. 运行 'python gitlab_timescale/sync_script.py --full-sync' 执行全量同步")
        logger.info("  3. 运行 'python gitlab_timescale/examples.py' 查看使用示例")
    else:
        logger.warning(f"\n⚠️ {total - passed} 个测试失败，请检查配置和环境")
        logger.info("\n🔧 故障排除建议:")
        logger.info("  1. 检查 .env 文件配置是否正确")
        logger.info("  2. 确认GitLab访问令牌有效")
        logger.info("  3. 确认TimescaleDB数据库可访问")
        logger.info("  4. 检查网络连接")


if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        logger.info("\n⏹️ 测试被用户中断")
    except Exception as e:
        logger.error(f"\n❌ 测试过程中发生异常: {e}")
        import traceback

        traceback.print_exc()
